package com.example.controller;

import com.example.domain.dto.unit.CreateUnitConversionRequest;
import com.example.domain.dto.unit.CreateUnitRequest;
import com.example.domain.dto.unit.UnitConversionRuleDTO;
import com.example.domain.dto.unit.UnitDTO;
import com.example.exception.ApiResponse;
import com.example.service.UnitService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.Collections;
import java.util.List;

/**
 * 单位管理Controller
 * 
 * <p>提供单位和单位换算规则的管理接口，包括：
 * <ul>
 *   <li>单位CRUD操作</li>
 *   <li>单位换算规则管理</li>
 *   <li>单位列表查询</li>
 * </ul>
 * </p>
 * 
 * @author Means
 * @since 2025-10-28
 */
@Slf4j
@RestController
@RequestMapping("/api/units")
@RequiredArgsConstructor
public class UnitController {
    
    private final UnitService unitService;
    
    // ==================== 单位管理 ====================
    
    /**
     * 创建单位
     * 
     * @param request 创建单位请求
     * @return 创建的单位DTO
     */
    @PostMapping
    public ApiResponse<UnitDTO> createUnit(@Valid @RequestBody CreateUnitRequest request) {
        log.info("创建单位: code={}, name={}", request.getCode(), request.getName());
        UnitDTO unit = unitService.createUnit(request);
        log.info("单位创建成功: code={}", unit.getCode());
        return ApiResponse.success(unit);
    }
    
    /**
     * 根据代码获取单位详情
     * 
     * @param code 单位代码
     * @return 单位DTO
     */
    @GetMapping("/{code}")
    public ApiResponse<UnitDTO> getUnit(@PathVariable String code) {
        log.debug("获取单位详情: code={}", code);
        UnitDTO unit = unitService.getUnitByCode(code);
        return ApiResponse.success(unit);
    }
    
    /**
     * 查询所有单位列表
     * 
     * @return 单位列表
     */
    @GetMapping
    public ApiResponse<List<UnitDTO>> getAllUnits() {
        log.debug("查询所有单位列表");
        List<UnitDTO> units = unitService.getAllUnits();
        log.debug("查询到 {} 个单位", units.size());
        return ApiResponse.success(units);
    }
    
    /**
     * 删除单位
     * 
     * @param code 单位代码
     * @return 成功响应
     */
    @DeleteMapping("/{code}")
    public ApiResponse<Void> deleteUnit(@PathVariable String code) {
        log.info("删除单位: code={}", code);
        unitService.deleteUnit(code);
        log.info("单位删除成功: code={}", code);
        return ApiResponse.success();
    }
    
    // ==================== 单位换算规则管理 ====================
    
    /**
     * 创建单位换算规则
     * 
     * @param request 创建换算规则请求
     * @return 创建的换算规则DTO
     */
    @PostMapping("/conversions")
    public ApiResponse<UnitConversionRuleDTO> createConversionRule(
            @Valid @RequestBody CreateUnitConversionRequest request) {
        log.info("创建单位换算规则: {} -> {}, factor={}", 
                request.getFromUnit(), request.getToUnit(), request.getFactor());
        UnitConversionRuleDTO rule = unitService.createConversionRule(request);
        log.info("换算规则创建成功: id={}", rule.getId());
        return ApiResponse.success(rule);
    }
    
    /**
     * 查询单位的所有换算规则
     * 
     * @param unitCode 单位代码
     * @return 换算规则列表
     */
    @GetMapping("/conversions")
    public ApiResponse<List<UnitConversionRuleDTO>> getConversionRules(
            @RequestParam(required = false) String unitCode) {
        if (unitCode != null) {
            log.debug("查询单位的换算规则: unitCode={}", unitCode);
            List<UnitConversionRuleDTO> rules = unitService.getConversionRulesByUnit(unitCode);
            log.debug("查询到 {} 条换算规则", rules.size());
            return ApiResponse.success(rules);
        } else {
            log.debug("未指定单位代码，返回空列表");
            return ApiResponse.success(Collections.emptyList());
        }
    }
    
    // 注：换算规则的详细查询和状态更新功能暂未被前端使用
}

